package controller;

import dao.CorrecaoListaAlunoJpaController;
import java.util.List;
import java.text.DecimalFormat;
import java.util.ArrayList;
import model.Aluno;
import model.Conteudo;
import model.ConteudoDaEmenta;
import model.CorrecaoListaAluno;
import model.DisciplinaProfessor;
import model.Ementa;
import model.Lista;
import model.ListaAluno;
import model.Matriculado;
import model.QuestaoAbordaConteudo;
import model.QuestaoLista;
import model.Turma;
import org.primefaces.component.chart.bar.BarChart;
import org.primefaces.model.chart.CartesianChartModel;
import org.primefaces.model.chart.ChartSeries;
import org.primefaces.model.chart.PieChartModel;
import pagecontroller.JsfUtil;

/**
 *
 * @author Edilson Fernandes da Costa
 * @version 1.0
 */
public class RelatorioController extends Controller {

    public RelatorioController() {
        if (JsfUtil.getObjectFromSession("CorrecaoListaAlunoJpaController") == null) {
            jpaController = new CorrecaoListaAlunoJpaController();
        } else {
            jpaController = (CorrecaoListaAlunoJpaController) JsfUtil.getObjectFromSession("CorrecaoListaAlunoJpaController");
        }
    }
    private CorrecaoListaAlunoJpaController jpaController = null;
    private List<QuestaoLista> questaoListas;
    private Lista lista;
    private List<String> relatorioLista;
    private List<String> relatorioEmenta;
    private List<String> relatorioConteudo;
    private List<String> relatorioAluno;
    private List<String> relatorioTurma;
    private List<String> conteudoAluno;
    private int colls;
    private List<Ementa> ementas;
    private List<Conteudo> conteudos;
    private Aluno aluno;
    private List<Aluno> alunos;
    private PieChartModel pieConteudoLista;
    private PieChartModel pieConteudoAluno;
    private PieChartModel pieConteudoTurma;
    private List<Turma> turmas;
    private Turma turma;
    private CartesianChartModel categoryModel;
    private ChartSeries chartConteudo;

    public void clear() {
        relatorioLista = null;
        relatorioEmenta = null;
        relatorioTurma = null;
        questaoListas = null;
        ementas = null;
        conteudos = null;
        aluno = null;
        alunos = null;
        conteudoAluno = null;
        turmas = null;
//        turma = null;

    }

    public String setPageRelatorioDesempenhoLista() {
        getPageManager().setPageRelatorioDesempenhoLista();
        getPageManager().setModalRelatorioDesempenhoLista();
        clear();
        return "refreshPage";
    }

    public String setPageRelatorioDesempenhoTurma() {
        getPageManager().setPageRelatorioDesempenhoTurma();
        getPageManager().setModalDesempenhoTurmaSelect();
        clear();
        return "refreshPage";
    }

    public String setPageRelatorioDesempenhoAluno() {
        getPageManager().setPageRelatorioDesempenhoAluno();
        getPageManager().setModalDesempenhoAlunoSelect();
        clear();
        return "refreshPage";
    }

    public List<String> getRelatorioLista() {
        Integer[] total = new Integer[1];
        DecimalFormat fmt = new DecimalFormat("0.00");

        if (relatorioLista == null) {

            relatorioLista = new ArrayList<String>();
            if (getLista() != null && getLista().getId() != null) {

                getLista().setQuestaoListas(getQuestaoListaController().getQuestaoListas(getLista()));

                setColls(getLista().getQuestaoListas().size() + 3);
                getListaController().setListaAux(lista);
                relatorioLista.add("Alunos");
                if (getLista().getQuestaoListas() != null) {
                    int i = 0;

                    for (QuestaoLista ql : getLista().getQuestaoListas()) {
                        relatorioLista.add("Questão " + (++i));
//                        relatorioLista.add(ql.getQuestaoProfessor().getQuestao().getEnunciado());
                    }

                    total = new Integer[i];
                    for (int tot = 0; tot < total.length; tot++) {
                        total[tot] = new Integer(0);
                    }

                    relatorioLista.add("Resultado");
                    relatorioLista.add("Aproveitamento (%)");
                    for (ListaAluno la : getListaAlunoController().getListaAlunosLista2(getLista())) {
                        relatorioLista.add(la.getAluno().getNome());
                        Integer nota = 0;
                        Integer notaMaxima = 0;
                        int j = 0;
                        for (QuestaoLista ql : getQuestaoListas()) {
                            //verifica se ja esta no banco                    
                            List<CorrecaoListaAluno> clas = jpaController.findCorrecaoListaAluno(la, ql);
                            if (clas != null && clas.size() > 0) {
                                relatorioLista.add(clas.get(0).getNota().toString());
                                nota += clas.get(0).getNota();
                                total[j] += clas.get(0).getNota();
                            } //se nao esta adiciona na lista
                            else {
                                relatorioLista.add("-");
                            }
                            notaMaxima += 100;
                            j++;
                        }

                        relatorioLista.add(nota.toString());

                        if (notaMaxima == 0) {
                            notaMaxima = 1;
                        }

                        Double ap = (Double.parseDouble(nota.toString()) / Double.parseDouble(notaMaxima.toString())) * 100;

                        relatorioLista.add(fmt.format(ap));
                    }

                }
                relatorioLista.add(("Total (%)"));



                int rown = getListaAlunoController().getListaAlunosLista2(getLista()).size();

                Double totalGeral = 0.0;
                for (Integer t : total) {
                    Double d = Double.parseDouble(t.toString()) / rown;
                    relatorioLista.add(fmt.format(d));
                    totalGeral += d;
                }

                relatorioLista.add(fmt.format(totalGeral));


                Double ap = (Double.parseDouble(totalGeral.toString()) / total.length);

                relatorioLista.add(fmt.format(ap));

            }
        }

        return relatorioLista;
    }

    public void setRelatorioLista(List<String> relatorioLista) {
        this.relatorioLista = relatorioLista;
    }

    public int getColls() {
        return colls;
    }

    public void setColls(int colls) {
        this.colls = colls;
    }

    public Lista getLista() {
        if (lista == null) {
            lista = getRenewListaController().getListaAux();
            if (lista == null) {
                lista = new Lista();
            }
        }
        return lista;
    }

    public void setLista(Lista lista) {
        clear();
        this.lista = lista;
    }

    public List<QuestaoLista> getQuestaoListas() {
        if (questaoListas == null) {
            questaoListas = getRenewQuestaoListaController().getQuestaoListas(getLista());
            if (questaoListas == null) {
                questaoListas = new ArrayList<QuestaoLista>();
            }
        }
        return questaoListas;
    }

    public List<Conteudo> getConteudos() {
        if (conteudos == null) {
            conteudos = new ArrayList<Conteudo>();
            if (getLista().getId() != null) {
                for (QuestaoLista ql : getQuestaoListaController().getQuestaoListas(getLista())) {
                    for (QuestaoAbordaConteudo qac : getQuestaoAbordaConteudoController().getQuestaoAbordaConteudos(ql.getQuestaoProfessor())) {
                        conteudos.add(qac.getConteudo());
                    }
                }
            }
        }
        return conteudos;
    }

    public List<Conteudo> getConteudos(Lista listaTemp) {
        if (conteudos == null) {
            conteudos = new ArrayList<Conteudo>();
            if (getLista().getId() != null) {
                for (QuestaoLista ql : getQuestaoListaController().getQuestaoListas(listaTemp)) {
                    for (QuestaoAbordaConteudo qac : getQuestaoAbordaConteudoController().getQuestaoAbordaConteudos(ql.getQuestaoProfessor())) {
                        conteudos.add(qac.getConteudo());
                    }
                }
            }
        }
        return conteudos;
    }

    public void setConteudos(List<Conteudo> conteudos) {
        this.conteudos = conteudos;
    }

    public List<Ementa> getEmentas() {
        if (ementas == null) {

            ementas = new ArrayList<Ementa>();
            for (Conteudo c : getConteudos()) {
                for (ConteudoDaEmenta cde : getConteudoDaEmentaController().getConteudoDaEmentas(c)) {
                    ementas.add(cde.getEmenta());
                }
            }

        }
        return ementas;
    }

    public void setEmentas(List<Ementa> ementas) {
        this.ementas = ementas;
    }

    public List<String> getRelatorioEmenta() {
        relatorioEmenta = new ArrayList<String>();
        relatorioEmenta.add("Ementa");
        relatorioEmenta.add("Disciplina");
        relatorioEmenta.add("% na lista");

        List<Ementa> ementas2 = new ArrayList<Ementa>();


        for (Ementa e : getEmentas()) {
            if (!ementas2.contains(e)) {
                ementas2.add(e);
            }
        }

        Integer[] qnt = new Integer[ementas2.size()];
        for (int n = 0; n < qnt.length; n++) {
            qnt[n] = new Integer(0);
        }

        List<Ementa> ementas3 = new ArrayList<Ementa>();
        ementas3.addAll(ementas);
        int i = 0;
        for (Ementa e : ementas2) {
            while (ementas3.contains(e)) {
                qnt[i] += 1;
                ementas3.remove(e);
            }
            i++;
        }

        int j = 0;
        DecimalFormat fmt = new DecimalFormat("0.00");
        Double d = 0.0;
        for (Ementa e : ementas2) {
            relatorioEmenta.add(e.getEmenta());
            relatorioEmenta.add(e.getDisciplinaProfessor().getDisciplina().getNome());

            d = (Double.parseDouble(qnt[j++].toString()) / ementas.size()) * 100;
//            relatorioEmenta.add(qnt[j++].toString());
            relatorioEmenta.add(fmt.format(d) + "%");
        }

        return relatorioEmenta;
    }

    public void setRelatorioEmenta(List<String> relatorioEmentaConteudo) {
        this.relatorioEmenta = relatorioEmentaConteudo;
    }

    public List<String> getRelatorioConteudo() {
        relatorioConteudo = new ArrayList<String>();
        relatorioConteudo.add("Conteudo");
        relatorioConteudo.add("Disciplina");



        List<Conteudo> conteudos2 = new ArrayList<Conteudo>();


        for (Conteudo e : getConteudos()) {
            if (!conteudos2.contains(e)) {
                conteudos2.add(e);
            }
        }

        Integer[] qnt = new Integer[conteudos2.size()];
        for (int n = 0; n < qnt.length; n++) {
            qnt[n] = new Integer(0);
        }

        List<Conteudo> conteudos3 = new ArrayList<Conteudo>();
        conteudos3.addAll(conteudos);
        int i = 0;
        for (Conteudo e : conteudos2) {
            while (conteudos3.contains(e)) {
                qnt[i] += 1;
                conteudos3.remove(e);
            }
            i++;
        }

        int j = 0;
        DecimalFormat fmt = new DecimalFormat("0.00");
        Double d = 0.0;

        setPieConteudoLista(new PieChartModel());
        for (Conteudo e : conteudos2) {
            relatorioConteudo.add(e.getConteudo());

            d = (Double.parseDouble(qnt[j++].toString()) / conteudos.size()) * 100;
//            relatorioConteudo.add(qnt[j++].toString());
            relatorioConteudo.add(fmt.format(d) + "%");

            pieConteudoLista.set(e.getConteudo(), d);

        }




//        for (Conteudo c : getConteudos()) {
//            relatorioConteudo.add(c.getConteudo());
//            relatorioConteudo.add("xx");
//
//        }
        return relatorioConteudo;

    }

    public void setRelatorioConteudo(List<String> relatorioConteudo) {
        this.relatorioConteudo = relatorioConteudo;
    }

    public PieChartModel getPieConteudoLista() {
        return pieConteudoLista;
    }

    public void setPieConteudoLista(PieChartModel pieConteudoLista) {
        this.pieConteudoLista = pieConteudoLista;
    }

    public Aluno getAluno() {
        if (aluno == null) {
            if (getAlunos() != null && getAlunos().size() > 0) {
                aluno = getAlunos().get(0);
            }
        }
        if (aluno == null) {
            aluno = new Aluno();
        }
        return aluno;
    }

    public void setAluno(Aluno aluno) {
        clear();
        this.aluno = aluno;
    }

    public List<Aluno> getAlunos() {
        alunos = getAlunoController().getAlunos();
        return alunos;
    }

    public void setAlunos(List<Aluno> alunos) {
        this.alunos = alunos;
    }

    public List<String> getRelatorioAluno() {
        relatorioAluno = new ArrayList<String>();
//        List<ListaAluno> listaAlunos = getListaAlunoController().getJpaController().findListaAluno(getAluno());

        relatorioAluno.add("Lista");
        relatorioAluno.add("Nota");

        Integer nota = 0;

        for (ListaAluno la : getListaAlunoController().getListaAlunos(getAluno())) {
            relatorioAluno.add(la.getLista().getTitulo());
            nota = 0;
            
            List<CorrecaoListaAluno> clas = getCorrecaoListaAlunoController().getCorrecaoListaAlunos(la);
            for (CorrecaoListaAluno cla : clas) {
                nota += cla.getNota();
            }
            
            Double d = (Double.parseDouble(nota.toString())/clas.size());
            DecimalFormat fmt = new DecimalFormat("0.00");
            relatorioAluno.add(fmt.format(d) + "%");
        }

        return relatorioAluno;
    }

    public void setRelatorioAluno(List<String> relatorioAluno) {
        this.relatorioAluno = relatorioAluno;
    }

    public List<String> getConteudoAluno() {

        if (conteudoAluno == null) {

            conteudoAluno = new ArrayList<String>();
//        List<ListaAluno> listaAlunos = getListaAlunoController().getJpaController().findListaAluno(getAluno());
            conteudoAluno.add("Conteudo");
            conteudoAluno.add("%");
            conteudoAluno.add("Aproveitamento");


            List<Integer> desempenhoConteudo = new ArrayList<Integer>();

            conteudos = new ArrayList<Conteudo>();
            for (ListaAluno la : getListaAlunoController().getListaAlunos(getAluno())) {

                List<QuestaoLista> qls = getQuestaoListaController().getQuestaoListas(la.getLista());

                for (QuestaoLista ql : qls) {

                    List<QuestaoAbordaConteudo> qacs = getQuestaoAbordaConteudoController().getQuestaoAbordaConteudos(ql.getQuestaoProfessor());

                    List<CorrecaoListaAluno> clas = getCorrecaoListaAlunoController().getJpaController().findCorrecaoListaAluno(la, ql);
                    Integer des = 0;
                    for (CorrecaoListaAluno cla : clas) {
                        des += cla.getNota();
                    }

                    for (QuestaoAbordaConteudo qac : qacs) {
                        conteudos.add(qac.getConteudo());
                        desempenhoConteudo.add(des);
//                        conteudoAluno.add(qac.getConteudo().getConteudo());
//                        conteudoAluno.add("");
                    }

                }
            }





            List<Conteudo> conteudos2 = new ArrayList<Conteudo>();
            for (Conteudo e : getConteudos()) {
                if (!conteudos2.contains(e)) {
                    conteudos2.add(e);
                }
            }

            Integer[] qnt = new Integer[conteudos2.size()];
            for (int n = 0; n < qnt.length; n++) {
                qnt[n] = new Integer(0);
            }

            Integer[] desen = new Integer[conteudos2.size()];
            for (int n = 0; n < qnt.length; n++) {
                desen[n] = new Integer(0);
            }

            List<Conteudo> conteudos3 = new ArrayList<Conteudo>();
            conteudos3.addAll(conteudos);
            int i = 0;
            for (Conteudo e : conteudos2) {
                while (conteudos3.contains(e)) {
                    qnt[i] += 1;
                    desen[i] += desempenhoConteudo.get(conteudos3.indexOf(e));
                    desempenhoConteudo.remove(conteudos3.indexOf(e));
                    conteudos3.remove(e);
                }
                i++;
            }

            int j = 0;
            DecimalFormat fmt = new DecimalFormat("0.00");
            Double d = 0.0;
            Double t = 0.0;


            Integer totDesen = 0;
            Double totDesenD = 0.0;

            Double[] desenD = new Double[conteudos2.size()];
            for (int n = 0; n < desen.length; n++) {
//                desenD[n] = new Double(0.0);
                desenD[n] = Double.parseDouble(desen[n].toString()) / qnt[n];

            }




            for (Integer inte : desen) {
                totDesen += inte;
            }

            for (Double de : desenD) {
                totDesenD += de;
            }



            categoryModel = new CartesianChartModel();
            chartConteudo = new ChartSeries("Conteudo");
            setPieConteudoAluno(new PieChartModel());
            for (Conteudo e : conteudos2) {
                conteudoAluno.add(e.getConteudo());

                d = (Double.parseDouble(qnt[j].toString()) / conteudos.size()) * 100;
                t = (Double.parseDouble(desen[j].toString()) / totDesen) * 100;
                t = (Double.parseDouble(desenD[j].toString()));
//                        |/ desenD.length) * 100;


//            relatorioConteudo.add(qnt[j++].toString());
                conteudoAluno.add(fmt.format(d) + "%");
                conteudoAluno.add(fmt.format(t) + "%");
//                conteudoAluno.add("");

                pieConteudoAluno.set(e.getConteudo(), d);
                chartConteudo.set(e.getConteudo(), t);

                j++;
            }
            categoryModel.addSeries(chartConteudo);
        }
        return conteudoAluno;
    }

    public void setConteudoAluno(List<String> conteudoAluno) {
        this.conteudoAluno = conteudoAluno;
    }

    public PieChartModel getPieConteudoAluno() {
        return pieConteudoAluno;
    }

    public void setPieConteudoAluno(PieChartModel pieConteudoAluno) {
        this.pieConteudoAluno = pieConteudoAluno;
    }

    public List<String> getRelatorioTurma() {

        if (relatorioTurma == null) {
            relatorioTurma = new ArrayList<String>();

            relatorioTurma.add("Conteudo");
            relatorioTurma.add("%");
            relatorioTurma.add("Aproveitamento");


            List<Conteudo> conteudosTurma = getConteudoController().getConteudos(getTurma().getPlano());

//            for (Conteudo c : conteudosTurma) {
//                relatorioTurma.add(c.getConteudo());
//                relatorioTurma.add("");
//                relatorioTurma.add("");
//            }

            List<Aluno> alunosTurma = new ArrayList();
            List<Integer> desempenhoConteudo = new ArrayList<Integer>();

            for (Matriculado m : getMatriculadoController().getMatriculados(getTurma())) {
                alunosTurma.add(m.getAluno());
            }




            conteudos = new ArrayList<Conteudo>();


            for (Aluno a : alunosTurma) {



                for (ListaAluno la : getListaAlunoController().getListaAlunos(a)) {

                    List<QuestaoLista> qls = getQuestaoListaController().getQuestaoListas(la.getLista());

                    for (QuestaoLista ql : qls) {

                        List<QuestaoAbordaConteudo> qacs = getQuestaoAbordaConteudoController().getQuestaoAbordaConteudos(ql.getQuestaoProfessor());

                        List<CorrecaoListaAluno> clas = getCorrecaoListaAlunoController().getJpaController().findCorrecaoListaAluno(la, ql);
                        Integer des = 0;
                        for (CorrecaoListaAluno cla : clas) {
                            des += cla.getNota();
                        }

                        for (QuestaoAbordaConteudo qac : qacs) {
                            if (conteudosTurma.contains(qac.getConteudo())) {
                                conteudos.add(qac.getConteudo());
                                desempenhoConteudo.add(des);
                            }
//                        conteudoAluno.add(qac.getConteudo().getConteudo());
//                        conteudoAluno.add("");
                        }

                    }
                }

            }




            List<Conteudo> conteudos2 = new ArrayList<Conteudo>();
            for (Conteudo e : getConteudos()) {
                if (!conteudos2.contains(e)) {
                    conteudos2.add(e);
                }
            }

            Integer[] qnt = new Integer[conteudos2.size()];
            for (int n = 0; n < qnt.length; n++) {
                qnt[n] = new Integer(0);
            }

            Integer[] desen = new Integer[conteudos2.size()];
            for (int n = 0; n < qnt.length; n++) {
                desen[n] = new Integer(0);
            }

            List<Conteudo> conteudos3 = new ArrayList<Conteudo>();
            conteudos3.addAll(conteudos);
            int i = 0;
            for (Conteudo e : conteudos2) {
                while (conteudos3.contains(e)) {
                    qnt[i] += 1;
                    desen[i] += desempenhoConteudo.get(conteudos3.indexOf(e));
                    desempenhoConteudo.remove(conteudos3.indexOf(e));
                    conteudos3.remove(e);
                }
                i++;
            }

            int j = 0;
            DecimalFormat fmt = new DecimalFormat("0.00");
            Double d = 0.0;
            Double t = 0.0;


            Integer totDesen = 0;
            Double totDesenD = 0.0;

            Double[] desenD = new Double[conteudos2.size()];
            for (int n = 0; n < desen.length; n++) {
//                desenD[n] = new Double(0.0);
                desenD[n] = Double.parseDouble(desen[n].toString()) / qnt[n];

            }




            for (Integer inte : desen) {
                totDesen += inte;
            }

            for (Double de : desenD) {
                totDesenD += de;
            }


            categoryModel = new CartesianChartModel();
            chartConteudo = new ChartSeries("Conteudo");
            setPieConteudoTurma(new PieChartModel());
            for (Conteudo e : conteudos2) {
                relatorioTurma.add(e.getConteudo());

                d = (Double.parseDouble(qnt[j].toString()) / conteudos.size()) * 100;
                t = (Double.parseDouble(desen[j].toString()) / totDesen) * 100;
                t = (Double.parseDouble(desenD[j].toString()));
//                        |/ desenD.length) * 100;


//            relatorioConteudo.add(qnt[j++].toString());
                relatorioTurma.add(fmt.format(d) + "%");
                relatorioTurma.add(fmt.format(t) + "%");
//                conteudoAluno.add("");

                pieConteudoTurma.set(e.getConteudo(), d);
                chartConteudo.set(e.getConteudo(), t);



                j++;
            }
            categoryModel.addSeries(chartConteudo);

        }

        return relatorioTurma;
    }

    public void setRelatorioTurma(List<String> relatorioTurma) {
        this.relatorioTurma = relatorioTurma;
    }

    public Turma getTurma() {
        if (turma == null) {
            if (getTurmas() != null && turmas.size() > 0) {
                turma = turmas.get(0);
            }
            if (turma == null) {
                turma = new Turma();
            }

        }

        return turma;
    }

    public void setTurma(Turma turma) {
        clear();
        this.turma = turma;
    }

    public List<Turma> getTurmas() {
//        if (turmas == null) {

        turmas = new ArrayList<Turma>();
        for (DisciplinaProfessor dp : getDisciplinaProfessorController().getDisciplinaProfessorLogado()) {
            turmas.addAll(getTurmaController().getTurmas(dp));
//            }
        }
        return turmas;
    }

    public void setTurmas(List<Turma> turmas) {
        this.turmas = turmas;
    }

    public CartesianChartModel getCategoryModel() {
        if (categoryModel == null) {
            categoryModel = new CartesianChartModel();
        }
        return categoryModel;
    }

    public void setCategoryModel(CartesianChartModel categoryModel) {
        this.categoryModel = categoryModel;
    }

    public ChartSeries getChartConteudo() {
        if (chartConteudo == null) {
            chartConteudo = new ChartSeries();
        }
        return chartConteudo;
    }

    public void setChartConteudo(ChartSeries chartConteudo) {
        this.chartConteudo = chartConteudo;
    }

    public PieChartModel getPieConteudoTurma() {
        return pieConteudoTurma;
    }

    public void setPieConteudoTurma(PieChartModel pieConteudoTurma) {
        this.pieConteudoTurma = pieConteudoTurma;
    }
}
